"""
DataFrame 操作模块

该模块提供了一个封装 Pandas DataFrame 的 Table 类，简化了数据处理的常用操作，主要功能包括：
1. 数据读写：支持 CSV、Excel 文件的加载与保存
2. 数据查看：获取行列数据、头部/尾部记录、数据信息与描述统计
3. 数据修改：添加/删除列、添加行、重命名、类型转换、插入数据
4. 数据清洗：处理缺失值、删除重复项、检测空值
5. 数据操作：筛选、排序、采样、转置、透视表、数据展开
6. 数据合并：支持多表连接、拼接操作
7. 统计分析：计算相关系数、唯一值、分组聚合
8. 数据可视化：绘制柱状图、折线图等基础图表
"""
import pandas as pd
import matplotlib.pyplot as plt
from typing import Union, List, Dict, Any

class Table:
    """
    整合 DataFrame 功能的类，简化 DataFrame 常用操作的使用。
    
    Attributes:
        df (pd.DataFrame): 内部使用的 Pandas DataFrame 实例。
    """
    
    def __init__(self, data: Union[Dict, pd.DataFrame] = None) -> None:
        """
        初始化 Table 类。
        
        Args:
            data (Union[Dict, pd.DataFrame], optional): 初始化数据。默认为 None。
        """
        if isinstance(data, pd.DataFrame):
            self.df = data.copy()
        elif isinstance(data, dict):
            self.df = pd.DataFrame(data)
        else:
            self.df = pd.DataFrame()

    def __str__(self) -> str:
        """
        返回 DataFrame 的字符串表示。
        
        Returns:
            str: DataFrame 的字符串表示。
        """
        return str(self.df)

    def __repr__(self) -> str:
        """
        返回 DataFrame 的官方字符串表示。
        
        Returns:
            str: DataFrame 的官方字符串表示。
        """
        return repr(self.df)

    # ------------------------------ 数据读写 ------------------------------
    def load_from_csv(self, file_path: str, **kwargs) -> None:
        """
        从 CSV 文件加载数据。
        
        Args:
            file_path (str): CSV 文件路径。
            **kwargs: 传递给 pd.read_csv 的参数。
        """
        self.df = pd.read_csv(file_path, **kwargs)

    def save_to_csv(self, file_path: str, **kwargs) -> None:
        """
        将数据保存到 CSV 文件。
        
        Args:
            file_path (str): CSV 文件路径。
            **kwargs: 传递给 pd.DataFrame.to_csv 的参数。
        """
        self.df.to_csv(file_path, **kwargs)

    def load_from_xlsx(self, file_path: str, **kwargs) -> None:
        """
        从 Excel 文件加载数据。
        
        Args:
            file_path (str): Excel 文件路径。
            **kwargs: 传递给 pd.read_excel 的参数。
        """
        self.df = pd.read_excel(file_path, **kwargs)

    def save_to_xlsx(self, file_path: str, **kwargs) -> None:
        """
        将数据保存到 Excel 文件。
        
        Args:
            file_path (str): Excel 文件路径。
            **kwargs: 传递给 pd.DataFrame.to_excel 的参数。
        """
        self.df.to_excel(file_path, **kwargs)

    # ------------------------------ 数据查看与选择 ------------------------------
    def get_columns(self) -> List[str]:
        """
        获取所有列名。
        
        Returns:
            List[str]: 列名列表。
        """
        return self.df.columns.tolist()

    def get_row_count(self) -> int:
        """
        获取行数。
        
        Returns:
            int: 行数。
        """
        return len(self.df)

    def head(self, n: int = 5) -> 'Table':
        """
        返回前 n 行数据。
        
        Args:
            n (int, optional): 返回的行数。默认为 5。
        
        Returns:
            Table: 前 n 行数据。
        """
        return Table(self.df.head(n))

    def tail(self, n: int = 5) -> 'Table':
        """
        返回后 n 行数据。
        
        Args:
            n (int, optional): 返回的行数。默认为 5。
        
        Returns:
            Table: 后 n 行数据。
        """
        return Table(self.df.tail(n))

    def iloc(self, index: Union[int, slice, List[int]]) -> Union['Table', pd.Series]:
        """
        通过整数位置选择数据。
        
        Args:
            index (Union[int, slice, List[int]]): 整数位置索引。
        
        Returns:
            Union[Table, pd.Series]: 选择的数据。
        """
        result = self.df.iloc[index]
        return Table(result) if isinstance(result, pd.DataFrame) else result

    def get_row(self, index: Union[int, str]) -> pd.Series:
        """
        获取指定索引的行数据。
        
        Args:
            index (Union[int, str]): 行索引。
        
        Returns:
            pd.Series: 行数据。
        """
        return self.df.loc[index]

    def get_column(self, column_name: str) -> pd.Series:
        """
        获取指定列的数据。
        
        Args:
            column_name (str): 列名。
        
        Returns:
            pd.Series: 列数据。
        """
        return self.df[column_name]

    def get_value(self, row_index: Union[int, str], column_name: str) -> Any:
        """
        获取指定位置的数据。
        
        Args:
            row_index (Union[int, str]): 行索引。
            column_name (str): 列名。
        
        Returns:
            Any: 指定位置的数据。
        """
        return self.df.loc[row_index, column_name]

    def info(self) -> None:
        """
        打印 DataFrame 的基本信息。
        """
        self.df.info()

    # ------------------------------ 数据修改与转换 ------------------------------
    def add_column(self, column_name: str, data: Optional[List] = None, default: Any = '') -> None:
        """
        添加新列，支持默认值填充。
        
        Args:
            column_name (str): 新列名。
            data (Optional[List], optional): 新列数据。如果为None，则使用default值填充。默认为None。
            default (Any, optional): 当data为None时使用的默认值。默认为空字符串。
        """
        if data is None:
            data = [default] * len(self.df) if not self.df.empty else []
        self.df[column_name] = data

    def add_row(self, row_data: Dict[str, Any]) -> None:
        """
        添加一行数据到表中。
        
        Args:
            row_data (Dict[str, Any]): 新行数据，键为列名，值为对应数据。
        """
        self.df.loc[len(self.df)] = row_data

    def remove_column(self, column_name: str) -> None:
        """
        移除指定列。
        
        Args:
            column_name (str): 要移除的列名。
        """
        if column_name in self.df.columns:
            self.df.drop(columns=[column_name], inplace=True)

    def rename_columns(self, columns: Dict[str, str]) -> None:
        """
        修改列名。
        
        Args:
            columns (Dict[str, str]): 旧列名到新列名的映射字典。
        """
        self.df.rename(columns=columns, inplace=True)

    def insert(self, loc: int, column: str, value=None, default: Any = '', allow_duplicates: bool = False) -> None:
        """
        在指定位置插入列，支持默认值填充。
        
        Args:
            loc (int): 插入位置。
            column (str): 列名。
            value (optional): 列值。如果为None，则使用default值填充。默认为None。
            default (Any, optional): 当value为None时使用的默认值。默认为空字符串。
            allow_duplicates (bool, optional): 是否允许列名重复。默认为 False。
        """
        if value is None:
            value = [default] * len(self.df) if not self.df.empty else []
        self.df.insert(loc, column, value, allow_duplicates=allow_duplicates)

    def drop(self, labels: Union[str, List[str]], axis: int = 0, **kwargs) -> None:
        """
        删除指定的行或列。
        
        Args:
            labels (Union[str, List[str]]): 要删除的行或列标签。
            axis (int, optional): 删除轴 (0 或 'index', 1 或 'columns')。默认为 0。
            **kwargs: 传递给 pd.DataFrame.drop 的参数。
        """
        self.df.drop(labels=labels, axis=axis, **kwargs, inplace=True)

    def convert_column_type(self, column_name: str, dtype: type) -> None:
        """
        转换指定列的数据类型。
        
        Args:
            column_name (str): 列名。
            dtype (type): 目标数据类型。
        """
        self.df[column_name] = self.df[column_name].astype(dtype)

    def astype(self, dtype: Union[type, Dict[str, type]], **kwargs) -> 'Table':
        """
        转换数据类型。
        
        Args:
            dtype (Union[type, Dict[str, type]]): 目标数据类型或列到数据类型的映射。
            **kwargs: 传递给 pd.DataFrame.astype 的参数。
        
        Returns:
            Table: 转换数据类型后的 DataFrame。
        """
        return Table(self.df.astype(dtype, **kwargs))

    def to_datetime(self, column: str, format: str = None) -> 'Table':
        """
        将指定列转换为日期时间类型。
        
        Args:
            column (str): 指定列名。
            format (str, optional): 日期时间格式。如果为 None，则自动推断。默认为 None。
        
        Returns:
            Table: 转换后的新 Table 对象。
        """
        new_df = self.df.copy()
        new_df[column] = pd.to_datetime(new_df[column], format=format)
        return Table(new_df)

    def rename_index(self, mapper: Union[Dict, callable], **kwargs) -> None:
        """
        重命名索引。
        
        Args:
            mapper (Union[Dict, callable]): 索引映射字典或函数。
            **kwargs: 传递给 pd.DataFrame.rename_axis 的参数。
        """
        self.df.rename_axis(index=mapper, **kwargs, inplace=True)

    def to_dict(self, orient: str = 'dict', **kwargs) -> Dict:
        """
        将 DataFrame 转换为字典。
        
        Args:
            orient (str, optional): 字典的格式。默认为 'dict'。
            **kwargs: 传递给 pd.DataFrame.to_dict 的参数。
        
        Returns:
            Dict: 转换后的字典。
        """
        return self.df.to_dict(orient=orient, **kwargs)

    # ------------------------------ 数据清洗 ------------------------------
    def drop_duplicates(self, subset: Union[str, List[str]] = None, keep: str = 'first') -> None:
        """
        删除重复行。
        
        Args:
            subset (Union[str, List[str]], optional): 用于识别重复项的列，默认为所有列。
            keep (str, optional): 保留哪些重复项 ('first', 'last', False)。默认为 'first'。
        """
        self.df.drop_duplicates(subset=subset, keep=keep, inplace=True)

    def fillna(self, value: Any = None, method: str = None, **kwargs) -> None:
        """
        填充缺失值。
        
        Args:
            value (Any, optional): 用于填充缺失值的值。默认为 None。
            method (str, optional): 填充方法 ('backfill', 'bfill', 'pad', 'ffill')。默认为 None。
            **kwargs: 传递给 pd.DataFrame.fillna 的参数。
        """
        self.df.fillna(value=value, method=method, **kwargs, inplace=True)

    def dropna(self, axis: int = 0, how: str = 'any', **kwargs) -> None:
        """
        删除包含缺失值的行或列。
        
        Args:
            axis (int, optional): 删除轴 (0 或 'index', 1 或 'columns')。默认为 0。
            how (str, optional): 删除方式 ('any', 'all')。默认为 'any'。
            **kwargs: 传递给 pd.DataFrame.dropna 的参数。
        """
        self.df.dropna(axis=axis, how=how, **kwargs, inplace=True)

    def isna(self) -> 'Table':
        """
        检测缺失值。
        
        Returns:
            Table: 缺失值检测结果。
        """
        return Table(self.df.isna())

    # ------------------------------ 数据操作 ------------------------------
    def filter_rows(self, condition: str) -> 'Table':
        """
        根据条件过滤行。
        
        Args:
            condition (str): Pandas 查询条件字符串。
        
        Returns:
            Table: 过滤后的新 Table 实例。
        """
        return Table(self.df.query(condition))

    def sort_by(self, column_name: str, ascending: bool = True) -> None:
        """
        根据指定列排序。
        
        Args:
            column_name (str): 排序列名。
            ascending (bool, optional): 是否升序。默认为 True。
        """
        self.df.sort_values(by=column_name, ascending=ascending, inplace=True)

    def sort_index(self, axis: int = 0, ascending: bool = True, **kwargs) -> 'Table':
        """
        对索引进行排序。
        
        Args:
            axis (int, optional): 排序的轴 (0 或 'index', 1 或 'columns')。默认为 0。
            ascending (bool, optional): 是否升序排序。默认为 True。
            **kwargs: 传递给 pd.DataFrame.sort_index 的参数。
        
        Returns:
            Table: 排序后的 DataFrame。
        """
        return Table(self.df.sort_index(axis=axis, ascending=ascending, **kwargs))

    def reset_index(self, drop: bool = False, **kwargs) -> 'Table':
        """
        重置索引。
        
        Args:
            drop (bool, optional): 是否丢弃原索引。默认为 False。
            **kwargs: 传递给 pd.DataFrame.reset_index 的参数。
        
        Returns:
            Table: 重置索引后的 DataFrame。
        """
        return Table(self.df.reset_index(drop=drop, **kwargs))

    def sample(self, n: int = None, frac: float = None, replace: bool = False, random_state: int = None) -> 'Table':
        """
        从数据中随机采样。
        
        Args:
            n (int, optional): 要采样的行数。默认为 None。
            frac (float, optional): 要采样的比例。默认为 None。
            replace (bool, optional): 是否有放回采样。默认为 False。
            random_state (int, optional): 随机数种子。默认为 None。
        
        Returns:
            Table: 采样后的数据。
        """
        return Table(self.df.sample(n=n, frac=frac, replace=replace, random_state=random_state))

    def T(self) -> 'Table':
        """
        转置 DataFrame。
        
        Returns:
            Table: 转置后的 DataFrame。
        """
        return Table(self.df.T)

    def explode(self, column: str) -> 'Table':
        """
        将包含列表或数组的列展开为多行。
        
        Args:
            column (str): 指定列名。
        
        Returns:
            Table: 展开后的新 Table 对象。
        """
        return Table(self.df.explode(column))

    def melt(self, id_vars: list = None, value_vars: list = None, var_name: str = 'variable', value_name: str = 'value') -> 'Table':
        """
        将宽格式数据转换为长格式数据。
        
        Args:
            id_vars (list, optional): 不需要被转换的列名列表。默认为 None。
            value_vars (list, optional): 需要被转换的列名列表。默认为 None。
            var_name (str, optional): 转换后变量列的名称。默认为 'variable'。
            value_name (str, optional): 转换后值列的名称。默认为 'value'。
        
        Returns:
            Table: 转换后的新 Table 对象。
        """
        return Table(self.df.melt(id_vars=id_vars, value_vars=value_vars, var_name=var_name, value_name=value_name))

    def resample(self, rule: str, on: str = None) -> 'Table':
        """
        对时间序列数据进行重采样。
        
        Args:
            rule (str): 重采样规则，例如 'D' 表示按天，'M' 表示按月。
            on (str, optional): 用于重采样的列名。如果为 None，则使用索引。默认为 None。
        
        Returns:
            Table: 重采样后的新 Table 对象。
        """
        return Table(self.df.resample(rule, on=on))

    def apply(self, func, axis: int = 0, **kwargs) -> Any:
        """
        对 DataFrame 应用函数。
        
        Args:
            func: 要应用的函数。
            axis (int, optional): 应用函数的轴 (0 或 'index', 1 或 'columns')。默认为 0。
            **kwargs: 传递给 pd.DataFrame.apply 的参数。
        
        Returns:
            Any: 应用函数后的结果。
        """
        return self.df.apply(func, axis=axis, **kwargs)

    # ------------------------------ 数据合并与连接 ------------------------------
    def merge(self, other: 'Table', on: Union[str, List[str]], how: str = 'inner') -> 'Table':
        """
        合并两个 Table。
        
        Args:
            other (Table): 要合并的另一个 Table 实例。
            on (Union[str, List[str]]): 合并依据的列名。
            how (str, optional): 合并方式。默认为 'inner'。
        
        Returns:
            Table: 合并后的新 Table 实例。
        """
        return Table(pd.merge(self.df, other.df, on=on, how=how))

    def merge_columns(self, left_on: str, right_table: 'Table', right_on: str = None, how: str = 'inner') -> 'Table':
        """
        合并两个 Table 对象。
        
        Args:
            left_on (str): 左表用于合并的列名。
            right_table (Table): 要合并的右表。
            right_on (str, optional): 右表用于合并的列名。如果为 None，则使用 left_on。默认为 None。
            how (str, optional): 合并方式 ('left', 'right', 'outer', 'inner')。默认为 'inner'。
        
        Returns:
            Table: 合并后的新 Table 对象。
        """
        if right_on is None:
            right_on = left_on
        return Table(pd.merge(self.df, right_table.df, left_on=left_on, right_on=right_on, how=how))

    def concat(self, other: 'Table', axis: int = 0, **kwargs) -> 'Table':
        """
        拼接两个 Table。
        
        Args:
            other (Table): 要拼接的另一个 Table 实例。
            axis (int, optional): 拼接轴 (0 或 'index', 1 或 'columns')。默认为 0。
            **kwargs: 传递给 pd.concat 的参数。
        
        Returns:
            Table: 拼接后的数据。
        """
        return Table(pd.concat([self.df, other.df], axis=axis, **kwargs))

    # ------------------------------ 分组与聚合 ------------------------------
    def group_by(self, column_name: str) -> Dict[str, 'Table']:
        """
        根据指定列分组。
        
        Args:
            column_name (str): 分组列名。
        
        Returns:
            Dict[str, Table]: 分组结果字典。
        """
        grouped = self.df.groupby(column_name)
        return {key: Table(group) for key, group in grouped}

    def pivot_table(self, values: Union[str, List[str]] = None, index: Union[str, List[str]] = None, 
                    columns: Union[str, List[str]] = None, aggfunc: Any = 'mean', **kwargs) -> 'Table':
        """
        创建数据透视表。
        
        Args:
            values (Union[str, List[str]], optional): 要聚合的列。默认为 None。
            index (Union[str, List[str]], optional): 透视表的索引。默认为 None。
            columns (Union[str, List[str]], optional): 透视表的列。默认为 None。
            aggfunc (Any, optional): 聚合函数。默认为 'mean'。
            **kwargs: 传递给 pd.pivot_table 的参数。
        
        Returns:
            Table: 数据透视表结果。
        """
        return Table(pd.pivot_table(self.df, values=values, index=index, columns=columns, aggfunc=aggfunc, **kwargs))

    # ------------------------------ 统计分析 ------------------------------
    def get_column_stats(self, column_name: str) -> Dict:
        """
        获取指定列的统计信息。
        
        Args:
            column_name (str): 列名。
        
        Returns:
            Dict: 统计信息字典。
        """
        return self.df[column_name].describe().to_dict()

    def describe(self, include: Union[str, List[str]] = None, exclude: Union[str, List[str]] = None, **kwargs) -> 'Table':
        """
        生成描述性统计信息。
        
        Args:
            include (Union[str, List[str]], optional): 包含的列。默认为 None。
            exclude (Union[str, List[str]], optional): 排除的列。默认为 None。
            **kwargs: 传递给 pd.DataFrame.describe 的参数。
        
        Returns:
            Table: 描述性统计信息。
        """
        return Table(self.df.describe(include=include, exclude=exclude, **kwargs))

    def corr(self, method: str = 'pearson', min_periods: int = 1) -> 'Table':
        """
        计算列与列之间的相关系数。
        
        Args:
            method (str, optional): 相关系数计算方法 ('pearson', 'kendall', 'spearman')。默认为 'pearson'。
            min_periods (int, optional): 每个列对所需的最小观测值数量。默认为 1。
        
        Returns:
            Table: 相关系数矩阵。
        """
        return Table(self.df.corr(method=method, min_periods=min_periods))

    def unique_values(self, column: str) -> list:
        """
        获取指定列的唯一值。
        
        Args:
            column (str): 指定列名。
        
        Returns:
            list: 包含唯一值的列表。
        """
        return self.df[column].unique().tolist()

    # ------------------------------ 数据可视化 ------------------------------
    def plot_bar(self, column: str, title: str = None, xlabel: str = None, ylabel: str = None, figsize: tuple = (10, 6)) -> None:
        """
        对指定列绘制柱状图。
        
        Args:
            column (str): 要绘制的列名。
            title (str, optional): 图表标题。默认为 None。
            xlabel (str, optional): x 轴标签。默认为 None。
            ylabel (str, optional): y 轴标签。默认为 None。
            figsize (tuple, optional): 图表尺寸。默认为 (10, 6)。
        """
        plt.figure(figsize=figsize)
        self.df[column].plot(kind='bar')
        if title:
            plt.title(title)
        if xlabel:
            plt.xlabel(xlabel)
        if ylabel:
            plt.ylabel(ylabel)
        plt.show()

    def plot_line(self, column: str, title: str = None, xlabel: str = None, ylabel: str = None, figsize: tuple = (10, 6)) -> None:
        """
        对指定列绘制折线图。
        
        Args:
            column (str): 要绘制的列名。
            title (str, optional): 图表标题。默认为 None。
            xlabel (str, optional): x 轴标签。默认为 None。
            ylabel (str, optional): y 轴标签。默认为 None。
            figsize (tuple, optional): 图表尺寸。默认为 (10, 6)。
        """
        plt.figure(figsize=figsize)
        self.df[column].plot(kind='line')
        if title:
            plt.title(title)
        if xlabel:
            plt.xlabel(xlabel)
        if ylabel:
            plt.ylabel(ylabel)
        plt.show()

    def drop_duplicates(self, subset: Union[str, List[str]] = None, keep: str = 'first') -> None:
        """
        删除重复行。
        
        Args:
            subset (Union[str, List[str]], optional): 用于识别重复项的列，默认为所有列。
            keep (str, optional): 保留哪些重复项 ('first', 'last', False)。默认为 'first'。
        """
        self.df.drop_duplicates(subset=subset, keep=keep, inplace=True)

    def fillna(self, value: Any = None, method: str = None, **kwargs) -> None:
        """
        填充缺失值。
        
        Args:
            value (Any, optional): 用于填充缺失值的值。默认为 None。
            method (str, optional): 填充方法 ('backfill', 'bfill', 'pad', 'ffill')。默认为 None。
            **kwargs: 传递给 pd.DataFrame.fillna 的参数。
        """
        self.df.fillna(value=value, method=method, **kwargs, inplace=True)

    def apply(self, func, axis: int = 0, **kwargs) -> Any:
        """
        对 DataFrame 应用函数。
        
        Args:
            func: 要应用的函数。
            axis (int, optional): 应用函数的轴 (0 或 'index', 1 或 'columns')。默认为 0。
            **kwargs: 传递给 pd.DataFrame.apply 的参数。
        
        Returns:
            Any: 应用函数后的结果。
        """
        return self.df.apply(func, axis=axis, **kwargs)

    def pivot_table(self, values: Union[str, List[str]] = None, index: Union[str, List[str]] = None, 
                    columns: Union[str, List[str]] = None, aggfunc: Any = 'mean', **kwargs) -> 'Table':
        """
        创建数据透视表。
        
        Args:
            values (Union[str, List[str]], optional): 要聚合的列。默认为 None。
            index (Union[str, List[str]], optional): 透视表的索引。默认为 None。
            columns (Union[str, List[str]], optional): 透视表的列。默认为 None。
            aggfunc (Any, optional): 聚合函数。默认为 'mean'。
            **kwargs: 传递给 pd.pivot_table 的参数。
        
        Returns:
            Table: 数据透视表结果。
        """
        return Table(pd.pivot_table(self.df, values=values, index=index, columns=columns, aggfunc=aggfunc, **kwargs))

    def sample(self, n: int = None, frac: float = None, replace: bool = False, random_state: int = None) -> 'Table':
        """
        从数据中随机采样。
        
        Args:
            n (int, optional): 要采样的行数。默认为 None。
            frac (float, optional): 要采样的比例。默认为 None。
            replace (bool, optional): 是否有放回采样。默认为 False。
            random_state (int, optional): 随机数种子。默认为 None。
        
        Returns:
            Table: 采样后的数据。
        """
        return Table(self.df.sample(n=n, frac=frac, replace=replace, random_state=random_state))

    def concat(self, other: 'Table', axis: int = 0, **kwargs) -> 'Table':
        """
        拼接两个 Table。
        
        Args:
            other (Table): 要拼接的另一个 Table 实例。
            axis (int, optional): 拼接轴 (0 或 'index', 1 或 'columns')。默认为 0。
            **kwargs: 传递给 pd.concat 的参数。
        
        Returns:
            Table: 拼接后的数据。
        """
        return Table(pd.concat([self.df, other.df], axis=axis, **kwargs))

    def iloc(self, index: Union[int, slice, List[int]]) -> Union['Table', pd.Series]:
        """
        通过整数位置选择数据。
        
        Args:
            index (Union[int, slice, List[int]]): 整数位置索引。
        
        Returns:
            Union[Table, pd.Series]: 选择的数据。
        """
        result = self.df.iloc[index]
        return Table(result) if isinstance(result, pd.DataFrame) else result

    def head(self, n: int = 5) -> 'Table':
        """
        返回前 n 行数据。
        
        Args:
            n (int, optional): 返回的行数。默认为 5。
        
        Returns:
            Table: 前 n 行数据。
        """
        return Table(self.df.head(n))

    def tail(self, n: int = 5) -> 'Table':
        """
        返回后 n 行数据。
        
        Args:
            n (int, optional): 返回的行数。默认为 5。
        
        Returns:
            Table: 后 n 行数据。
        """
        return Table(self.df.tail(n))

    def isna(self) -> 'Table':
        """
        检测缺失值。
        
        Returns:
            Table: 缺失值检测结果。
        """
        return Table(self.df.isna())

    def dropna(self, axis: int = 0, how: str = 'any', **kwargs) -> None:
        """
        删除包含缺失值的行或列。
        
        Args:
            axis (int, optional): 删除轴 (0 或 'index', 1 或 'columns')。默认为 0。
            how (str, optional): 删除方式 ('any', 'all')。默认为 'any'。
            **kwargs: 传递给 pd.DataFrame.dropna 的参数。
        """
        self.df.dropna(axis=axis, how=how, **kwargs, inplace=True)

    def T(self) -> 'Table':
        """
        转置 DataFrame。
        
        Returns:
            Table: 转置后的 DataFrame。
        """
        return Table(self.df.T)

    def rename_index(self, mapper: Union[Dict, callable], **kwargs) -> None:
        """
        重命名索引。
        
        Args:
            mapper (Union[Dict, callable]): 索引映射字典或函数。
            **kwargs: 传递给 pd.DataFrame.rename_axis 的参数。
        """
        self.df.rename_axis(index=mapper, **kwargs, inplace=True)

    def insert(self, loc: int, column: str, value, allow_duplicates: bool = False) -> None:
        """
        在指定位置插入列。
        
        Args:
            loc (int): 插入位置。
            column (str): 列名。
            value: 列值。
            allow_duplicates (bool, optional): 是否允许列名重复。默认为 False。
        """
        self.df.insert(loc, column, value, allow_duplicates=allow_duplicates)

    def drop(self, labels: Union[str, List[str]], axis: int = 0, **kwargs) -> None:
        """
        删除指定的行或列。
        
        Args:
            labels (Union[str, List[str]]): 要删除的行或列标签。
            axis (int, optional): 删除轴 (0 或 'index', 1 或 'columns')。默认为 0。
            **kwargs: 传递给 pd.DataFrame.drop 的参数。
        """
        self.df.drop(labels=labels, axis=axis, **kwargs, inplace=True)

    def astype(self, dtype: Union[type, Dict[str, type]], **kwargs) -> 'Table':
        """
        转换数据类型。
        
        Args:
            dtype (Union[type, Dict[str, type]]): 目标数据类型或列到数据类型的映射。
            **kwargs: 传递给 pd.DataFrame.astype 的参数。
        
        Returns:
            Table: 转换数据类型后的 DataFrame。
        """
        return Table(self.df.astype(dtype, **kwargs))

    def to_dict(self, orient: str = 'dict', **kwargs) -> Dict:
        """
        将 DataFrame 转换为字典。
        
        Args:
            orient (str, optional): 字典的格式。默认为 'dict'。
            **kwargs: 传递给 pd.DataFrame.to_dict 的参数。
        
        Returns:
            Dict: 转换后的字典。
        """
        return self.df.to_dict(orient=orient, **kwargs)

    def sort_index(self, axis: int = 0, ascending: bool = True, **kwargs) -> 'Table':
        """
        对索引进行排序。
        
        Args:
            axis (int, optional): 排序的轴 (0 或 'index', 1 或 'columns')。默认为 0。
            ascending (bool, optional): 是否升序排序。默认为 True。
            **kwargs: 传递给 pd.DataFrame.sort_index 的参数。
        
        Returns:
            Table: 排序后的 DataFrame。
        """
        return Table(self.df.sort_index(axis=axis, ascending=ascending, **kwargs))

    def reset_index(self, drop: bool = False, **kwargs) -> 'Table':
        """
        重置索引。
        
        Args:
            drop (bool, optional): 是否丢弃原索引。默认为 False。
            **kwargs: 传递给 pd.DataFrame.reset_index 的参数。
        
        Returns:
            Table: 重置索引后的 DataFrame。
        """
        return Table(self.df.reset_index(drop=drop, **kwargs))

    def info(self) -> None:
        """
        打印 DataFrame 的基本信息。
        """
        self.df.info()

    def describe(self, include: Union[str, List[str]] = None, exclude: Union[str, List[str]] = None, **kwargs) -> 'Table':
        """
        生成描述性统计信息。
        
        Args:
            include (Union[str, List[str]], optional): 包含的列。默认为 None。
            exclude (Union[str, List[str]], optional): 排除的列。默认为 None。
            **kwargs: 传递给 pd.DataFrame.describe 的参数。
        
        Returns:
            Table: 描述性统计信息。
        """
        return Table(self.df.describe(include=include, exclude=exclude, **kwargs))

    def corr(self, method: str = 'pearson', min_periods: int = 1) -> 'Table':
        """
        计算列与列之间的相关系数。
        
        Args:
            method (str, optional): 相关系数计算方法 ('pearson', 'kendall', 'spearman')。默认为 'pearson'。
            min_periods (int, optional): 每个列对所需的最小观测值数量。默认为 1。
        
        Returns:
            Table: 相关系数矩阵。
        """
        return Table(self.df.corr(method=method, min_periods=min_periods))

    def plot_bar(self, column: str, title: str = None, xlabel: str = None, ylabel: str = None, figsize: tuple = (10, 6)) -> None:
        """
        对指定列绘制柱状图。
        
        Args:
            column (str): 要绘制的列名。
            title (str, optional): 图表标题。默认为 None。
            xlabel (str, optional): x 轴标签。默认为 None。
            ylabel (str, optional): y 轴标签。默认为 None。
            figsize (tuple, optional): 图表尺寸。默认为 (10, 6)。
        """
        plt.figure(figsize=figsize)
        self.df[column].plot(kind='bar')
        if title:
            plt.title(title)
        if xlabel:
            plt.xlabel(xlabel)
        if ylabel:
            plt.ylabel(ylabel)
        plt.show()

    def plot_line(self, column: str, title: str = None, xlabel: str = None, ylabel: str = None, figsize: tuple = (10, 6)) -> None:
        """
        对指定列绘制折线图。
        
        Args:
            column (str): 要绘制的列名。
            title (str, optional): 图表标题。默认为 None。
            xlabel (str, optional): x 轴标签。默认为 None。
            ylabel (str, optional): y 轴标签。默认为 None。
            figsize (tuple, optional): 图表尺寸。默认为 (10, 6)。
        """
        plt.figure(figsize=figsize)
        self.df[column].plot(kind='line')
        if title:
            plt.title(title)
        if xlabel:
            plt.xlabel(xlabel)
        if ylabel:
            plt.ylabel(ylabel)
        plt.show()

    def merge_columns(self, left_on: str, right_table: 'Table', right_on: str = None, how: str = 'inner') -> 'Table':
        """
        合并两个 Table 对象。

        Args:
            left_on (str): 左表用于合并的列名。
            right_table (Table): 要合并的右表。
            right_on (str, optional): 右表用于合并的列名。如果为 None，则使用 left_on。默认为 None。
            how (str, optional): 合并方式 ('left', 'right', 'outer', 'inner')。默认为 'inner'。

        Returns:
            Table: 合并后的新 Table 对象。
        """
        if right_on is None:
            right_on = left_on
        return Table(pd.merge(self.df, right_table.df, left_on=left_on, right_on=right_on, how=how))

    def unique_values(self, column: str) -> list:
        """
        获取指定列的唯一值。

        Args:
            column (str): 指定列名。

        Returns:
            list: 包含唯一值的列表。
        """
        return self.df[column].unique().tolist()

    def resample(self, rule: str, on: str = None) -> 'Table':
        """
        对时间序列数据进行重采样。

        Args:
            rule (str): 重采样规则，例如 'D' 表示按天，'M' 表示按月。
            on (str, optional): 用于重采样的列名。如果为 None，则使用索引。默认为 None。

        Returns:
            Table: 重采样后的新 Table 对象。
        """
        return Table(self.df.resample(rule, on=on))

    def to_datetime(self, column: str, format: str = None) -> 'Table':
        """
        将指定列转换为日期时间类型。

        Args:
            column (str): 指定列名。
            format (str, optional): 日期时间格式。如果为 None，则自动推断。默认为 None。

        Returns:
            Table: 转换后的新 Table 对象。
        """
        new_df = self.df.copy()
        new_df[column] = pd.to_datetime(new_df[column], format=format)
        return Table(new_df)

    def explode(self, column: str) -> 'Table':
        """
        将包含列表或数组的列展开为多行。

        Args:
            column (str): 指定列名。

        Returns:
            Table: 展开后的新 Table 对象。
        """
        return Table(self.df.explode(column))

    def melt(self, id_vars: list = None, value_vars: list = None, var_name: str = 'variable', value_name: str = 'value') -> 'Table':
        """
        将宽格式数据转换为长格式数据。

        Args:
            id_vars (list, optional): 不需要被转换的列名列表。默认为 None。
            value_vars (list, optional): 需要被转换的列名列表。默认为 None。
            var_name (str, optional): 转换后变量列的名称。默认为 'variable'。
            value_name (str, optional): 转换后值列的名称。默认为 'value'。

        Returns:
            Table: 转换后的新 Table 对象。
        """
        return Table(self.df.melt(id_vars=id_vars, value_vars=value_vars, var_name=var_name, value_name=value_name))